////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2017-2018 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// THIS IS AUTO-GENERATED CODE.  PLEASE DO NOT EDIT (File bug reports against tools).
///
/// Auto-generated by: ParameterParser V1.1.4
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  afhafelements.h
/// @brief Auto-generated Chromatix parameter file
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef AFHAFELEMENTS_H
#define AFHAFELEMENTS_H

#include "parametermodule.h"
#include "parameterfilesymboltable.h"
#include "parametertypes.h"
#include "afglobalelements.h"

#define AFHAFELEMENTS_NAMESPACE_BEGIN namespace afhafelements {
#define AFHAFELEMENTS_NAMESPACE_END }

AFHAFELEMENTS_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFFocusValueStatsType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class chromatixAFFocusValueStatsType
{
    AF_FV_STATS_TYPE_HW_1 = 0,
    AF_FV_STATS_TYPE_HW_2 = 1,
    AF_FV_STATS_TYPE_SW   = 2,
    AF_FV_STATS_TYPE_MAX  = 3
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFFineSearchExtensionType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixAFFineSearchExtensionType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enable
    ///
    /// Description:   Flag to enable/disable the feature.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 enable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// maximumFineSearchExtensionCount
    ///
    /// Description:   Maximum number of times the extension can happen, Effect: Higher the number more the search time.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32  maximumFineSearchExtensionCount;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// numNearSteps
    ///
    /// Description:   Number of steps to be taken to the near end from the optimum lens position to get the near_end position.
    ///                Effect: Higher the number bigger the search range.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32  numNearSteps;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// numFarSteps
    ///
    /// Description:   Number of steps to be taken to the far end from the optimum lens position to get the far_end position.
    ///                Effect: Higher the number bigger the search range.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32  numFarSteps;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// stepSize
    ///
    /// Description:   Step size to determine the search range Effect: Higher the number bigger the search range.
    /// Range:         [0,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32  stepSize;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// decreaseDropRatio
    ///
    /// Description:   Threshold to determine the peak and stop the search. Effect: Higher the number easy to find the peak.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT  decreaseDropRatio;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixHAFGyroSettingsType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixHAFGyroSettingsType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableGyroSamplingRateAdjustment
    ///
    /// Description:   this is the gyro sampling rate dynamic adjustment enable flag. If enabled, gyro sampling rate will adjust
    ///                according to gyroSamplingRateMonitor, gyroSamplingRateSearching or gyroSamplingRateSearchingHj
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type enableGyroSamplingRateAdjustment;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// gyroSamplingRateMonitor
    ///
    /// Description:   this is the gyro sampling rate set to in mhz when AF enters monitor state. The value should be lower than
    ///                gyroSamplingRateSearching to reduce overrall power consumption.
    /// Range:         [0,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            gyroSamplingRateMonitor;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// gyroSamplingRateSearching
    ///
    /// Description:   this is the gyro sampling rate set to in mhz when AF enters searching state. This sampling rate is used
    ///                by legacy SAF(Non-HJ Single AF).
    /// Range:         [0,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            gyroSamplingRateSearching;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// gyroSamplingRateSearchingHJ
    ///
    /// Description:   this is the gyro sampling rate in mhz set to when AF enters searching state. This sampling rate is used
    ///                by HJ SAF(Hand-jitter Single AF)
    /// Range:         [0,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            gyroSamplingRateSearchingHJ;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFFollowerStepType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixAFFollowerStepType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// stepSize
    ///
    /// Description:   Step size in normal/low light for fine search when lens is in far position in
    ///                AF_FOLLOWER_MACRO_RANGE/AF_FOLLOWER_MID_RANGE/AF_FOLLOWER_FAR_RANGE.
    /// Range:         [0,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 stepSize;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// numFarSteps
    ///
    /// Description:   Number of Far steps in normal/low light for fine search when lens is in far position in
    ///                AF_FOLLOWER_MACRO_RANGE/AF_FOLLOWER_MID_RANGE/AF_FOLLOWER_FAR_RANGE.
    /// Range:         [0,20]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 numFarSteps;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// numNearSteps
    ///
    /// Description:   Number of Near steps in normal/low light for fine search when lens is in near position in
    ///                AF_FOLLOWER_MACRO_RANGE/AF_FOLLOWER_MID_RANGE/AF_FOLLOWER_FAR_RANGE.
    /// Range:         [0,20]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 numNearSteps;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixSearchInfoType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixSearchInfoType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// AFFollowerMacroRange
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFFollowerStepType AFFollowerMacroRange;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// AFFollowerMidRange
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFFollowerStepType AFFollowerMidRange;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// AFFollowerFarRange
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFFollowerStepType AFFollowerFarRange;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixFollowerFineSearchInfoType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixFollowerFineSearchInfoType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// normalLightFineSearchInfo
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixSearchInfoType normalLightFineSearchInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// lowLightFineSearchInfo
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixSearchInfoType lowLightFineSearchInfo;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixHAFFollowerSettingsType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixHAFFollowerSettingsType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableFollower
    ///
    /// Description:   Enable Follower tuning from Reserve params.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type                    enableFollower;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// AFFollowerFineSearchSettings
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixFollowerFineSearchInfoType AFFollowerFineSearchSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableGravityCompensationForFollower
    ///
    /// Description:   Enable Gravity Compensation for Follower.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type                    enableGravityCompensationForFollower;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// jumpToStartLimitForFollower
    ///
    /// Description:   Maximum lens pos that can be moved in one go. Constraints: Value should not be more than what is
    ///                supported by actuator.
    /// Range:         [20,300]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                               jumpToStartLimitForFollower;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// lowLightThresholdForFollower
    ///
    /// Description:   Threshold used to compare against Scene BV to check if we are in Low Light.
    /// Range:         [0,8]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                               lowLightThresholdForFollower;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// useFineSearchExtensionForFollower
    ///
    /// Description:   If Fine search extension needs to be enabled in HAF.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type                    useFineSearchExtensionForFollower;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// activeConvergenceFollowForFollower
    ///
    /// Description:   If Follower needs to actively follow Master during convergence Constraints: Should be a Boolean value.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type                    activeConvergenceFollowForFollower;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// lensPosThresholdForActiveConvergenceFollow
    ///
    /// Description:   Lets follower know if Lens position is varying by this value, it need to move the lens Constraints:
    ///                should be less than max jump limit.
    /// Range:         [0,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                               lensPosThresholdForActiveConvergenceFollow;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// searchStrategy
    ///
    /// Description:   Search strategy used by Follower (0 for AF_FOLLOWER_COARSE_FOLLOW and 1 for AF_FOLLOWER_COMPLETE_FOLLOW).
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                               searchStrategy;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixHAFROISettingsType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixHAFROISettingsType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HAFROIEnable
    ///
    /// Description:   control enabling/disabling touch and face ROI handling in HAF.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            HAFROIEnable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HAFROIHNum
    ///
    /// Description:   Number of Horizontal PDAF window. Constraints: PDAF Type 1,2 and 3 currently supports only 1 window.
    /// Range:         [1,6]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            HAFROIHNum;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HAFROIVNum
    ///
    /// Description:   Number of Horizontal PDAF window. Constraints: PDAF Type 1,2 and 3 currently supports only 1 window.
    /// Range:         [1,8]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            HAFROIVNum;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HAFCenterROISize
    ///
    /// Description:   Default size of PDAF window at the center, Constraints: Value has to be smaller or equal to
    ///                hafCornerROISize.
    /// Range:         [0.2,0.3]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            HAFCenterROISize;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HAFCornerROISize
    ///
    /// Description:   Default size of PDAF window at the corner. ROI size will be interpolated between center and corner roi
    ///                size. Constraints: Value has to be larger or equal to hafCenterROISize.
    /// Range:         [0.2,0.3]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            HAFCornerROISize;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HAFROIDelay
    ///
    /// Description:   Specifies sensor specific delay to reflect new ROI. Should be configured as 'actual sensor delay' - 1.
    /// Range:         [0,2]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            HAFROIDelay;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableROIShifting
    ///
    /// Description:   If ROI Shifting needs to be enabled when HAF is in follow mode Constraints: should be a Boolean value.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type enableROIShifting;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ROIShiftType
    ///
    /// Description:   Informs HAF to do the particular ROI Shifting logic when in follow mode Constraints: should be capped to
    ///                3
    /// Range:         [0,2]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            ROIShiftType;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixHAFType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixHAFType
{
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Binary file symbol table entry ID
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 SymbolTableID;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// module_version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct module_versionStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;
        INT32 major_revision;
        INT32 minor_revision;
    } module_version;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// parameter_version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct parameter_versionStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;
        INT32 major_revision;
        INT32 minor_revision;
    } parameter_version;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enable_section
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct enable_sectionStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// CAFEnable
        ///
        /// Description:   Enable flag for CAF
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        afglobalelements::enable_flag_type CAFEnable;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// PDAFEnable
        ///
        /// Description:   Enable flag for PDAF
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        afglobalelements::enable_flag_type PDAFEnable;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// TOFEnable
        ///
        /// Description:   Enable flag for TOF
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        afglobalelements::enable_flag_type TOFEnable;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// DCIAFEnable
        ///
        /// Description:   Enable flag for DCIAF
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        afglobalelements::enable_flag_type DCIAFEnable;
    } enable_section;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// statsConsumeEnable - Array
    ///
    /// Description:   Array of usage enable flags for each stats. Default value: {0, 0, 0}.
    /// Range:         [0,1]
    /// Min Length:    1
    /// Max Length:    3
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                             statsConsumeEnableCount;
    UINT32                             statsConsumeEnableID;
    UINT32*                            statsConsumeEnable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// statsSelect
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFFocusValueStatsType     statsSelect;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// fineSearchDropThreshold
    ///
    /// Description:   FV drop ratio threshold to consider drop.
    /// Range:         [0.5,0.99]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                              fineSearchDropThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// fineStepSize
    ///
    /// Description:   Fine search step size. Should be same as single search fine step.
    /// Range:         [0,1000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                              fineStepSize;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// maxMoveStep
    ///
    /// Description:   Max lens move for UX.
    /// Range:         [0,1000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                              maxMoveStep;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// maxMoveStepBuffer
    ///
    /// Description:   Buffer step to avoid small lens movement.
    /// Range:         [0,1000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                              maxMoveStepBuffer;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// baseFrameDelay
    ///
    /// Description:   Base frane skip for HAF.
    /// Range:         [0,1000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                              baseFrameDelay;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// AFFineSearchExtension
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFFineSearchExtensionType AFFineSearchExtension;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sceneChangeDuringFS
    ///
    /// Description:   Flag to indicate if scene change happens during fine search then it would trigger new search.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                              sceneChangeDuringFS;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// faceCAFHighPriorityEnable
    ///
    /// Description:   Flag to indicate to give Face AF to be given priority over HAF.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type                   faceCAFHighPriorityEnable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableInitialPosition
    ///
    /// Description:   If this filed is enable, the initial/default lens position will be between [SINGLE_NEAR_LIMIT_IDX -
    ///                SINGLE_INF_LIMIT_IDX], otherwise default lens positing will be infinity.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type                   enableInitialPosition;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// initialLensIdx
    ///
    /// Description:   Index of initial lens position. This filed will be used if enableInitialPosition is enable.
    /// Range:         [0,11]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                              initialLensIdx;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// depthConfidenceCountThreshold
    ///
    /// Description:   The number of frames which algo should return confident in order to overwrite caf decision.
    /// Range:         [1,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                              depthConfidenceCountThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HAFROISettings
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixHAFROISettingsType        HAFROISettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HAFFollowerSettings
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixHAFFollowerSettingsType   HAFFollowerSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// macroRegionThresholdInMM
    ///
    /// Description:   Macro region threshold in mm.
    /// Range:         [0,10000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                              macroRegionThresholdInMM;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// farRegionThresholdinMM
    ///
    /// Description:   Far region threshold in mm.
    /// Range:         [0,10000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                              farRegionThresholdinMM;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// fineStartMoveBuffer
    ///
    /// Description:   This parameter is used to take decision in fine start pos move when frame skip is not enabled in fine
    ///                search. When frame skip in fine search is not enabled and move lens to fine start location is larger than
    ///                fine step size, we can move in two steps so that second step is same as fine step size. This parameter
    ///                takes decision in two step movement.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                              fineStartMoveBuffer;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// DOFMultiplier
    ///
    /// Description:   Represents the scaler by which the increase in lens depth-of-focus change from the far to the near focus
    ///                limit is estimated. This parameter is used to adjust the step size based on current location needed for
    ///                fine search extension functionality used in HAF. Constraints: Specifies a linear scaler used in modeling
    ///                the change in lens depth-of-focus from the far to the near focus limit
    /// Range:         [1,2]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                              DOFMultiplier;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableForceScanEnd
    ///
    /// Description:   This tunable flag is used to provide an option to abort the focus search based on timeout logic and the
    ///                do_af_call active focus call from AP. This is mainly used for apps which rely on focus status to trigger
    ///                snapshot.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type                   enableForceScanEnd;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enablePassiveScanTimeout
    ///
    /// Description:   Apart from the active scan timeout using the enableForceScanEnd, there is an option provided to timeout
    ///                in general for any passive search triggered by CAF based on scene change. When this flag is enabled,
    ///                counter would start for scanning and abort the search if the search continues too long. Uses the same
    ///                counter threshold as enable_force_scan_end.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type                   enablePassiveScanTimeout;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// maxScanCountThreshold
    ///
    /// Description:   This parameter represents the maximum numbers of frames any depth based AF can stay in focusing state.
    ///                Constraints: Tuning the value to a lower threshold would result in aborting the scan frequently. Higher
    ///                value would delay the snapshot trigger call for some apps.
    /// Range:         [0,60]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                              maxScanCountThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// gyroSettings
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixHAFGyroSettingsType       gyroSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableDynamicAnchorPoints
    ///
    /// Description:   This allows anchor points which is used for calculating, focal length ratio, distance to lens position
    ///                and vice versa to be tunable. Wide Lens can use anchor points of 20cm and 60cm while tele cannot use 20cm
    ///                since its minimum focusing distance may be more than that. Constraints: None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type                   enableDynamicAnchorPoints;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// anchorPosition1
    ///
    /// Description:   This value maps to SINGLE_20CM_IDX which is the anchor position Constraints: This value should be more
    ///                than then minimum focusing distance of the lens
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                              anchorPosition1;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// anchorPosition2
    ///
    /// Description:   This value maps to SINGLE_HYP_F_IDX which is the anchor position Constraints: this value should be less
    ///                than infinity as we can't calculate the distance for the same
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                              anchorPosition2;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// minimumFocusIndex
    ///
    /// Description:   This value maps to the minimum focusing distance of the lens which is SINGLE_7CM_IDX for most lens.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                              minimumFocusIndex;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HJNormalizedWeightType
    ///
    /// Description:   choose algorithm for HJ normalized weight value in AF single algorithm. 0 is using gyro to decide
    ///                normalization weight. 1 is using gyro difference to decide normalization weight. Constraints: tuning when
    ///                HAF fine search HJ_Algorithm is enable.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                              HJNormalizedWeightType;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CAFHJNormalizedWeightType
    ///
    /// Description:   choose algorithm for HJ normalized weight value in HAF fine search algorithm. 0 is using gyro to decide
    ///                normalization weight. 1 is using gyro difference to decide normalization weight. Constraints: tuning when
    ///                HAF fine search HJ_Algorithm is enable.
    /// Range:         [0,1000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                              CAFHJNormalizedWeightType;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// AFControlAECInfoEnable
    ///
    /// Description:   Flag to enable use fast frame rate in AF converge state. Constraints: tuning when HAF fine search
    ///                HJ_Algorithm is enable.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type                   AFControlAECInfoEnable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// AFControlAECInfoFPS
    ///
    /// Description:   we use fast fps in AF converge state. This value decide how much fps in AF converge state.
    /// Range:         [0,30]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                              AFControlAECInfoFPS;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// spd_stats_type
    ///
    /// Description:   Range: [0 or 1] 0 - 16x16 YSum stats 1 - 64x48 BG stats; Description: This flag determines spotlight
    ///                detection algorithm stats type. When value is 0, it runs with default 16x16 YSum stats. If the value is
    ///                1, then SPD will run with 64x48 BG stats which provides finer granularity. Constraints: None
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                              spd_stats_type;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// spd_bg_stats_thresh_auto_convert_enable
    ///
    /// Description:   When enable, all the YSum spotlight tuning thresholds will be auto converted to BG stats compatible
    ///                thresholds. For example, if spotlight tuning thresholds are start_h = 4 and end_h = 12, then with BG auto
    ///                convert, it will directly runtime change thresholds to start_h = 16 and en_h = 48(By multiplying the
    ///                BG/YSum grid ratio). If it is disabled, then the grids will be use as it is, and no auto-convert will
    ///                happen.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type                   spd_bg_stats_thresh_auto_convert_enable;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFFollowerDistanceType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class chromatixAFFollowerDistanceType
{
    AF_FOLLOWER_MACRO_RANGE = 0,
    AF_FOLLOWER_MID_RANGE   = 1,
    AF_FOLLOWER_FAR_RANGE   = 2,
    AF_FOLLOWER_MAX_RANGE   = 3
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixHAFTypeClass
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class chromatixHAFTypeClass : public ParameterModule, public chromatixHAFType
{
public:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const UINT16 MAJOR = 3;
    static const UINT16 MINOR = 4;
    static const UINT32 PATCH = 0;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Default Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixHAFTypeClass(
        const CHAR* name);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixHAFTypeClass(
        const CHAR* name,
        UINT32 modeId,
        UINT16 mode,
        UINT16 subMode,
        UINT32 group);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Destructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ~chromatixHAFTypeClass();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetName
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const CHAR* GetName(
        const CHAR* type);


    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixAFFineSearchExtensionType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixAFFineSearchExtensionType(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFFineSearchExtensionType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixHAFGyroSettingsType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixHAFGyroSettingsType(
        ParameterFileSymbolTableEntry* entry,
        chromatixHAFGyroSettingsType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixAFFollowerStepType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixAFFollowerStepType(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFFollowerStepType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixSearchInfoType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixSearchInfoType(
        ParameterFileSymbolTableEntry* entry,
        chromatixSearchInfoType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixFollowerFineSearchInfoType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixFollowerFineSearchInfoType(
        ParameterFileSymbolTableEntry* entry,
        chromatixFollowerFineSearchInfoType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixHAFFollowerSettingsType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixHAFFollowerSettingsType(
        ParameterFileSymbolTableEntry* entry,
        chromatixHAFFollowerSettingsType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixHAFROISettingsType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixHAFROISettingsType(
        ParameterFileSymbolTableEntry* entry,
        chromatixHAFROISettingsType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixHAFType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixHAFType(
        ParameterFileSymbolTableEntry* entry,
        chromatixHAFType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load module_versionStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadmodule_versionStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixHAFType::module_versionStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load parameter_versionStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadparameter_versionStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixHAFType::parameter_versionStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load enable_sectionStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadenable_sectionStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixHAFType::enable_sectionStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload chromatixHAFType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadchromatixHAFType(
        chromatixHAFType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Parse symbol table entry, and return a new object
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ParameterModule* Parse(
        ParameterSetManager* manager,
        ParameterFileSymbolTableEntry* entry) const;

}; // End class chromatixHAFTypeClass

AFHAFELEMENTS_NAMESPACE_END
#endif // AFHAFELEMENTS_H

